/LMAR=0/XLINE=50/FONT#0=BASL30[HAL, HE]/FONT#3=BASI30[HAL, HE]/FONT#4=BASB30/FONT#5=BDR40


␈↓"∧␈↓ ↓H␈↓␈↓ αλSTANFORD ARTIFICIAL INTELLIGENCE LABORATORY ␈↓ 
#APRIL 1975









␈↓"∧␈↓ ↓H␈↓␈↓ α(␈↓¬An Overview of AL, A Programming System for Automation





␈↓"∧␈↓ ↓H␈↓¬␈↓ αA␈↓Raphael Finkel, Russell Taylor, Robert Bolles, Richard Paul␈↓#
*␈↓#, Jerome Feldman␈↓#
*␈↓#








␈↓"↓␈↓ ↓H␈↓␈↓ βλAL␈α is␈α∨an␈α high-level␈α programming␈α∨system␈α for␈α specification␈α∨of
␈↓ ↓H␈↓␈↓ αHmanipulatory␈αtasks␈αsuch␈αas␈αassembly␈αof␈αan␈αobject␈αfrom␈αparts.␈α AL␈αincludes␈αan
␈↓ ↓H␈↓␈↓ αHALGOL-like␈α∃source␈α∃language,␈α∃a␈α∃translator␈α∃for␈α∃converting␈α∃programs␈α∃into
␈↓ ↓H␈↓␈↓ αHrunnable␈α∞code,␈α∞and␈α∞a␈α∞runtime␈α
system␈α∞for␈α∞controlling␈α∞manipulators␈α∞and␈α
other
␈↓ ↓H␈↓␈↓ αHdevices.␈α∩ The␈α∪system␈α∩includes␈α∩advanced␈α∪features␈α∩for␈α∪describing␈α∩individual
␈↓ ↓H␈↓␈↓ αHmotions␈α⊂of␈α⊂manipulators,␈α⊂for␈α⊂using␈α⊂sensory␈α⊂information,␈α⊂and␈α⊃for␈α⊂describing
␈↓ ↓H␈↓␈↓ αHassembly␈α⊃algorithms␈α⊃in␈α⊃terms␈α⊃of␈α⊃common␈α⊃domain-specific␈α⊃primitives.␈α⊂ This
␈↓ ↓H␈↓␈↓ αHpaper␈α
describes␈αthe␈α
design␈αof␈α
AL,␈α
which␈αis␈α
currently␈αbeing␈α
implemented␈α
as␈αa
␈↓ ↓H␈↓␈↓ αHsuccessor to the Stanford WAVE system.



␈↓"↓␈↓ ↓H␈↓␈↓ αλ______________________________________________________________________________________␈↓ >  

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β␈↓#
*␈↓#␈α⊗Jerome␈α↔Feldman␈α⊗is␈α↔now␈α⊗at␈α⊗the␈α↔University␈α⊗of␈α↔Rochester.␈α⊗ Lou␈α⊗Paul␈α↔is␈α⊗now␈α↔at␈α⊗the
␈↓ ↓H␈↓βStanford Research Institute.

␈↓"↓␈↓ ↓H␈↓β␈↓ αλThis␈α∪research␈α∪was␈α∪supported␈α∩in␈α∪part␈α∪by␈α∪the␈α∩National␈α∪Science␈α∪Foundation␈α∪under␈α∩contract
␈↓ ↓H␈↓βNo.␈α⊂GI-42906␈α⊂and␈α⊃in␈α⊂part␈α⊂by␈α⊂the␈α⊃Advanced␈α⊂Research␈α⊂Projects␈α⊂Agency␈α⊃of␈α⊂the␈α⊂Office␈α⊃of␈α⊂Defense
␈↓ ↓H␈↓βunder␈α⊗Contract␈α∃No.␈α⊗DAHC-15-73-C-0435.␈α⊗ The␈α∃views␈α⊗and␈α⊗conclusions␈α∃in␈α⊗this␈α⊗document␈α∃are
␈↓ ↓H␈↓βthose␈α⊗of␈α⊗the␈α⊗authors␈α⊗and␈α⊗should␈α⊗not␈α⊗be␈α⊗interpreted␈α⊗as␈α⊗necessarily␈α⊗representing␈α↔the␈α⊗official
␈↓ ↓H␈↓βpolicies, either expressed or implied, of the funding agencies.
␈↓ ↓H␈↓␈↓ εH␈↓ 
pPage 1



␈↓"∧␈↓ ↓H␈↓␈↓∧1 AN OVERVIEW OF AL␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλThis␈αshort␈αpaper␈αcannot␈αcover␈αthe␈αsubject␈αof␈αAL␈αwith␈αany␈αdepth;␈αa␈αcomplete␈αdiscussion␈αmay
␈↓ ↓H␈↓be␈α_found␈α_in␈α→␈↓βAL,␈α_A␈α_Programming␈α_System␈α→for␈α_Automation␈↓,␈α_Stanford␈α→Artificial␈α_Intelligence
␈↓ ↓H␈↓Laboratory␈α
Memo␈α
AIM-243,␈α
Stanford␈α
University␈α
Computer␈α
Science␈α
Department␈α∞Report␈α
STAN-
␈↓ ↓H␈↓CS-74-456, by the authors of this paper.



␈↓"↓␈↓ ↓H␈↓␈↓∧1.1 INTRODUCTION␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α∂development␈α∂of␈α∂robot␈α∂manipulators␈α∂such␈α∂as␈α∂the␈α∂"Unimate"␈α∂has␈α∂led␈α∂to␈α∂the␈α⊂belief␈α∂that
␈↓ ↓H␈↓these␈α
tools␈α
are␈α
in␈α
some␈α
way␈α
general-purpose␈α
devices␈α
and␈α
that␈α
they␈α
might␈α
be␈α
programmed␈α
like␈αa
␈↓ ↓H␈↓computer.␈α As␈α
a␈αgeneral-purpose␈α
programmable␈αdevice,␈α
the␈αrobot␈α
manipulator␈αprovides␈αan␈α
answer
␈↓ ↓H␈↓to␈αthe␈αneed␈α
for␈αautomation␈αof␈α
assembly␈αin␈αbatch␈α
manufacturing␈αindustries␈αwhere␈αsmall␈α
production
␈↓ ↓H␈↓runs rule out the use of special-purpose equipment.

␈↓"↓␈↓ ↓H␈↓␈↓ αλWe␈α∞are␈α
implementing␈α∞a␈α∞system␈α
called␈α∞AL␈α
for␈α∞small␈α∞scale␈α
batch␈α∞manufacturing␈α∞where␈α
setup
␈↓ ↓H␈↓time␈α
is␈αthe␈α
key␈αfactor.␈α
We␈αrely␈α
on␈α
a␈αsymbolic␈α
database␈αand␈α
previously-defined␈αassembly␈α
primitives
␈↓ ↓H␈↓to␈α∩minimize␈α∩programming␈α∩time.␈α∩The␈α∪system␈α∩is␈α∩capable␈α∩of␈α∩top-level␈α∩planning␈α∪and␈α∩intelligent
␈↓ ↓H␈↓interpretation␈α⊂of␈α⊂user␈α⊂defined␈α⊂primitives.␈α∂The␈α⊂principal␈α⊂aim␈α⊂of␈α⊂this␈α∂work␈α⊂is␈α⊂not␈α⊂to␈α⊂provide␈α∂a
␈↓ ↓H␈↓factory␈α⊃floor␈α∩programming␈α⊃system␈α∩but␈α⊃rather␈α∩to␈α⊃design␈α∩a␈α⊃language␈α∩which␈α⊃will␈α∩be␈α⊃a␈α∩tool␈α⊃for
␈↓ ↓H␈↓investigating␈α∂the␈α∞difficulty,␈α∂necessary␈α∂programming␈α∞time,␈α∂and␈α∂feasibility␈α∞of␈α∂writing␈α∂programs␈α∞to
␈↓ ↓H␈↓control assembly operations.



␈↓"↓␈↓ ↓H␈↓␈↓∧1.2 PHILOSOPHY OF DESIGN ␈↓



␈↓"↓␈↓ ↓H␈↓␈↓βDATA AND CONTROL STRUCTURES␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α∞principal␈α∞mode␈α∂of␈α∞input␈α∞to␈α∞AL␈α∂is␈α∞textual,␈α∞as␈α∞opposed␈α∂to␈α∞spoken␈α∞or␈α∂manual␈α∞(joystick).
␈↓ ↓H␈↓There␈α∞are␈α
levels␈α∞of␈α∞complexity␈α
which␈α∞are␈α∞much␈α
more␈α∞readily␈α∞transmitted␈α
from␈α∞man␈α∞to␈α
machine
␈↓ ↓H␈↓through␈α∞an␈α∞interface␈α∞of␈α∞symbolic␈α∞text.␈α∞ Simultaneous␈α∞motions␈α∞of␈α∞two␈α∞arms␈α∞and␈α∞termination␈α
and
␈↓ ↓H␈↓error␈αconditions␈α
are␈αmore␈α
likely␈αto␈α
be␈αunambiguously␈αdescribed␈α
through␈αthe␈α
medium␈αof␈α
text;␈αthe
␈↓ ↓H␈↓structure␈α
imposed␈α
on␈αthe␈α
textual␈α
language␈αforces␈α
a␈α
consistent␈αframework␈α
on␈α
initially␈αless␈α
structured
␈↓ ↓H␈↓intuitive␈α⊃ideas.␈α⊃ Non-textual␈α⊃forms␈α⊃of␈α⊃input␈α⊂for␈α⊃defining␈α⊃target␈α⊃locations␈α⊃and␈α⊃suggesting␈α⊂arm
␈↓ ↓H␈↓trajectories␈α
to␈α
avoid␈α
collisions␈αare␈α
most␈α
useful␈α
when␈α
applied␈αin␈α
conjunction␈α
with␈α
a␈α
program␈αtext
␈↓ ↓H␈↓which␈α⊃supplies␈α⊃the␈α⊂skeletal␈α⊃intent␈α⊃of␈α⊃the␈α⊂programmer.␈α⊃ The␈α⊃supervisor␈α⊂level␈α⊃of␈α⊃AL␈α⊃is␈α⊂simple
␈↓ ↓H␈↓enough␈α⊃to␈α⊃allow␈α⊃natural␈α⊃teaching␈α⊂by␈α⊃showing;␈α⊃it␈α⊃should␈α⊃be␈α⊂easy␈α⊃to␈α⊃interface␈α⊃such␈α⊃devices␈α⊂as
␈↓ ↓H␈↓joysticks and vocal input into AL, although we do not intend to do so at present.

␈↓"↓␈↓ ↓H␈↓␈↓ αλExperience␈α
with␈α
languages␈α
like␈α
SAIL␈α
and␈α
WAVE␈α
has␈α
shown␈α
that␈α
text␈α
macros␈α
are␈α
a␈αuseful
␈↓ ↓H␈↓feature;␈αthey␈α
reduce␈αthe␈α
amount␈αof␈α
repetitive␈αtyping.␈α
 AL␈αhas␈α
a␈αgeneral-purpose␈α
text␈αmacro␈α
system
␈↓ ↓H␈↓interfaced into the scanner and parser.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α
datatypes␈α
available␈α
include␈α
those␈α∞types␈α
necessary␈α
to␈α
refer␈α
to␈α∞one-dimensional␈α
measures
␈↓ ↓H␈↓(like␈α∀distance,␈α∀time,␈α∃mass)␈α∀and␈α∀three-dimensional␈α∃measures␈α∀(like␈α∀directed␈α∃distance,␈α∀locations,
␈↓ ↓H␈↓orientations).␈α∞Arithmetic␈α
operators␈α∞are␈α
available␈α∞not␈α∞only␈α
for␈α∞the␈α
standard␈α∞scalar␈α∞operations␈α
like
␈↓ ↓H␈↓multiplication and addition, but also for such operations as rotation and translation.

␈↓"↓␈↓ ↓H␈↓␈↓ αλProvision␈α
is␈α
made␈α
for␈α
simultaneous␈α
execution␈α
of␈α
several␈α
processes␈α
This␈α
allows␈αcalculation␈α
and
␈↓ ↓H␈↓arm␈α⊗motion␈α⊗to␈α∃take␈α⊗place␈α⊗simultaneously;␈α∃several␈α⊗manipulators␈α⊗can␈α∃be␈α⊗in␈α⊗independent␈α∃or
␈↓ ↓H␈↓coordinated motion.
␈↓ ↓H␈↓Page 2␈↓ ∧⎇PHILOSOPHY OF DESIGN ␈↓ ∂1.2.2



␈↓"∧␈↓ ↓H␈↓␈↓βMOTION SPECIFICATIONS␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλExperience␈αwith␈αWAVE␈αhas␈αshown␈αthat␈αcalculating␈αtrajectories␈αfor␈αmanipulators␈αis␈αdesirable
␈↓ ↓H␈↓but␈αtime-consuming.␈α
Trajectory␈αcalculations,␈αtogether␈α
with␈αall␈αother␈α
calculations␈αwhich␈α
need␈αonly
␈↓ ↓H␈↓be␈α∂performed␈α∂once,␈α∂are␈α∂done␈α∂at␈α⊂compile␈α∂time.␈α∂ This␈α∂allocation␈α∂of␈α∂effort␈α∂drastically␈α⊂reduces␈α∂the
␈↓ ↓H␈↓computing␈αload␈αat␈αexecution␈αtime␈αand␈αeliminates␈αwasteful␈αrecomputation␈αevery␈αtime␈αa␈αsequence␈αof
␈↓ ↓H␈↓actions␈α⊗is␈α⊗executed.␈α⊗ This␈α∃leads␈α⊗to␈α⊗a␈α⊗clear␈α∃distinction␈α⊗between␈α⊗compile-time␈α⊗and␈α∃runtime.
␈↓ ↓H␈↓Trajectories␈αmay␈αbe␈αspecified␈αto␈αpass␈αthrough␈α
given␈αintermediate␈αpoints.␈α The␈αprimary␈αuse␈αof␈α
this
␈↓ ↓H␈↓is to avoid collisions during the motion.  It is also useful in specifying complicated motions.

␈↓"↓␈↓ ↓H␈↓␈↓ αλA␈α⊃wide␈α∩range␈α⊃of␈α∩exceptional␈α⊃conditions␈α∩can␈α⊃occur␈α∩during␈α⊃the␈α∩motion␈α⊃of␈α∩a␈α⊃manipulator.
␈↓ ↓H␈↓Appropriate␈α
action␈α
must␈αbe␈α
taken␈α
as␈αsoon␈α
as␈α
any␈αof␈α
these␈α
occurs,␈αfor␈α
example␈α
to␈αstart␈α
up␈α
a␈αnew
␈↓ ↓H␈↓concurrent␈α∪process␈α∩or␈α∪to␈α∩notify␈α∪the␈α∩user.␈α∪ Therefore,␈α∩AL␈α∪allows␈α∩the␈α∪flexible␈α∪specification␈α∩of
␈↓ ↓H␈↓conditions␈α∞to␈α∞monitor␈α∞during␈α∞the␈α∞course␈α∞of␈α∞motions␈α∞(and␈α∞during␈α∞execution␈α∞of␈α∞blocks␈α∞of␈α∞code␈α∞in
␈↓ ↓H␈↓general), and what to do in the case that a tested condition occurs.



␈↓"↓␈↓ ↓H␈↓␈↓βUSE OF A PLANNING MODEL␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλSince␈α∞locations␈α∞are␈α∞not␈α∞known␈α∞exactly␈α∞during␈α∞the␈α∞planning␈α∞of␈α∞a␈α∞trajectory,␈α∞there␈α∞is␈α∂a␈α∞clear
␈↓ ↓H␈↓distinction␈α∞between␈α∞planned␈α∞values␈α
and␈α∞runtime␈α∞values.␈α∞ Planned␈α
values␈α∞are␈α∞used␈α∞for␈α
trajectory
␈↓ ↓H␈↓calculation;␈αat␈αruntime,␈α
trajectories␈αare␈αmodified␈α
if␈αnecessary␈αto␈α
account␈αfor␈αany␈αdiscrepancies.␈α
The
␈↓ ↓H␈↓planned␈α⊃values␈α⊃are␈α⊃therefore␈α⊂a␈α⊃database␈α⊃on␈α⊃which␈α⊂trajectory␈α⊃calculations␈α⊃are␈α⊃computed.␈α⊂This
␈↓ ↓H␈↓database forms a ␈↓βworld model␈↓.

␈↓"↓␈↓ ↓H␈↓␈↓ αλAssembly␈α
tasks␈α∞require␈α
that␈α∞one␈α
object␈α
be␈α∞affixed␈α
to␈α∞another.␈α
 We␈α
model␈α∞this␈α
by␈α∞having␈α
a
␈↓ ↓H␈↓semantic␈α
attachment␈α∞between␈α
objects.␈α∞If␈α
two␈α∞objects␈α
are␈α
affixed,␈α∞and␈α
one␈α∞moves,␈α
the␈α∞second␈α
one
␈↓ ↓H␈↓should␈α⊂move␈α⊂accordingly,␈α⊂that␈α⊂is,␈α⊂its␈α⊃planning␈α⊂value␈α⊂should␈α⊂be␈α⊂properly␈α⊂modified.␈α⊃The␈α⊂world
␈↓ ↓H␈↓model␈αincludes␈αinformation␈αon␈αattachments␈αof␈αobjects.␈α The␈αaffixment␈αconcept␈αcarries␈αover␈αto␈αthe
␈↓ ↓H␈↓runtime␈αsystem,␈α
which␈αdoes␈αthe␈α
equivalent␈αmodifications␈αof␈α
the␈αactual␈αvalues.␈α
 This␈αsaves␈αthe␈α
user
␈↓ ↓H␈↓untold bookkeeping operations to determine where an object is after its base has been moved.

␈↓"↓␈↓ ↓H␈↓␈↓ αλMore␈α
generally,␈α
the␈α
compiler␈α
maintains␈αa␈α
wide␈α
variety␈α
of␈α
information␈α
about␈αexpected␈α
runtime
␈↓ ↓H␈↓states.␈α∞ This␈α∞includes␈α∞information␈α∂like␈α∞the␈α∞accuracy␈α∞within␈α∂which␈α∞the␈α∞planning␈α∞value␈α∂is␈α∞known,
␈↓ ↓H␈↓how␈αheavy␈αan␈αobject␈αis,␈αhow␈α
many␈αfaces␈αit␈αhas␈αon␈αwhich␈αit␈α
can␈αrest,␈αhow␈αwide␈αthe␈αfingers␈α
of␈αan
␈↓ ↓H␈↓arm␈αshould␈αopen␈αto␈αgrasp␈αit.␈α This␈αinformation␈αmay␈αcome␈αfrom␈αseveral␈αsources,␈αincluding␈αexplicit
␈↓ ↓H␈↓assertions␈α⊂by␈α⊂the␈α⊂user␈α∂and␈α⊂built-in␈α⊂knowledge␈α⊂about␈α⊂the␈α∂system␈α⊂hardware.␈α⊂ AL␈α⊂has␈α⊂a␈α∂general
␈↓ ↓H␈↓framework for representing and using such knowledge.



␈↓"↓␈↓ ↓H␈↓␈↓βUSE OF DOMAIN-SPECIFIC KNOWLEDGE␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈αsystem␈αhas␈αenough␈αdomain-specific␈αknowledge␈αto␈αallow␈αprograms␈αto␈αbe␈αwritten␈αin␈αterms
␈↓ ↓H␈↓of␈α∞common␈α
assembly␈α∞operations,␈α
rather␈α∞than␈α
exclusively␈α∞in␈α
terms␈α∞of␈α
detailed␈α∞single␈α∞motions.␈α
 At
␈↓ ↓H␈↓the␈α∂simplest␈α∂level,␈α⊂this␈α∂involves␈α∂a␈α⊂library␈α∂of␈α∂common␈α⊂assembly␈α∂"macro-operations"␈α∂that␈α⊂can␈α∂be
␈↓ ↓H␈↓conditionally␈α⊂expanded␈α∂to␈α⊂perform␈α⊂particular␈α∂subtasks.␈α⊂ Beyond␈α⊂this,␈α∂we␈α⊂foresee␈α⊂an␈α∂interactive
␈↓ ↓H␈↓system␈αthat␈α
can␈αtake␈αa␈α
"high␈αlevel"␈αdescription␈α
of␈αan␈αassembly␈α
algorithm␈αand␈αfill␈α
in␈αmany␈α
of␈αthe
␈↓ ↓H␈↓detailed decisions required to produce a consistent and efficient output program.

␈↓"↓␈↓ ↓H␈↓␈↓ αλA␈α
user␈α∞can␈α
specify␈α
different␈α∞parts␈α
of␈α∞a␈α
task␈α
at␈α∞various␈α
levels␈α
of␈α∞detail.␈α
 The␈α∞system␈α
accepts
␈↓ ↓H␈↓explicit␈α∪advice␈α∪telling␈α∪exactly␈α∪how␈α∪some␈α∪particular␈α∪subtask␈α∪is␈α∪to␈α∪be␈α∪accomplished␈α∪and␈α∩then
␈↓ ↓H␈↓completes␈α∩the␈α∩program␈α∩in␈α∩a␈α∩way␈α∩that␈α⊃does␈α∩not␈α∩conflict␈α∩with␈α∩that␈α∩advice.␈α∩ This␈α∩is␈α⊃especially
␈↓ ↓H␈↓important␈α∂for␈α∞early␈α∂versions␈α∞of␈α∂AL,␈α∞which␈α∂are␈α∂not␈α∞likely␈α∂to␈α∞be␈α∂very␈α∞"smart"␈α∂and␈α∂will␈α∞therefore
␈↓ ↓H␈↓require a fair amount of explicit help.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α∪user␈α∩can␈α∪make␈α∪assertions␈α∩describing␈α∪the␈α∪"intent"␈α∩of␈α∪a␈α∪particular␈α∩piece␈α∪of␈α∪code␈α∩by
␈↓ ↓H␈↓specifying␈αany␈α(non-obvious)␈αprerequisites␈αor␈αupdates␈αto␈αthe␈αworld␈αmodel.␈α Such␈αinformation␈αcan
␈↓ ↓H␈↓1.2.4␈↓ ∧⎇PHILOSOPHY OF DESIGN ␈↓ 
pPage 3



␈↓"∧␈↓ ↓H␈↓be␈αused␈α
by␈αthe␈α
AL␈αstrategist␈αto␈α
generate␈αcode␈α
to␈αcause␈αthe␈α
desired␈αresult.␈α
 This␈αfacility␈αis␈α
especially
␈↓ ↓H␈↓important␈α∞for␈α∞programs␈α∞that␈α∞mix␈α∞both␈α∂high␈α∞and␈α∞low-level␈α∞primitives.␈α∞Similarly,␈α∞the␈α∂system␈α∞can
␈↓ ↓H␈↓show␈αthe␈α
user␈αhow␈α
it␈αis␈αfilling␈α
in␈αthe␈α
details␈αto␈α
produce␈αan␈αoutput␈α
program,␈αand␈α
why.␈αThis␈αis␈α
very
␈↓ ↓H␈↓important␈αboth␈αfor␈αdebugging␈αand␈αfor␈αexplaining␈αto␈αthe␈αuser␈αany␈αrequests␈αfor␈αadvice␈αthat␈αit␈αmust
␈↓ ↓H␈↓make.



␈↓"↓␈↓ ↓H␈↓␈↓βTHE RUNTIME SYSTEM␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈αcalculation␈αof␈αtrajectories␈αis␈αtime-consuming␈αbut␈αnot␈αtime-critical;␈αservoing␈αof␈αdevices␈αis
␈↓ ↓H␈↓time-critical␈αbut␈αnot␈αespecially␈αtime-consuming.␈α The␈α
compiler␈αis␈αwritten␈αin␈αa␈αhigh-level␈α
language,
␈↓ ↓H␈↓SAIL,␈α
and␈α∞the␈α
runtime␈α
programs␈α∞are␈α
written␈α∞in␈α
assembly␈α
language.␈α∞ As␈α
one␈α∞execution␈α
computer
␈↓ ↓H␈↓will␈α∂be␈α⊂required␈α∂for␈α∂each␈α⊂work␈α∂station␈α∂in␈α⊂a␈α∂factory,␈α∂and␈α⊂as␈α∂the␈α∂runtime␈α⊂code␈α∂and␈α⊂its␈α∂memory
␈↓ ↓H␈↓requirements will be quite small, the runtime system is designed for a minicomputer.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α≤runtime␈α≤system␈α≠supports␈α≤simultaneous␈α≤executions␈α≠of␈α≤many␈α≤processes.␈α≠ Several
␈↓ ↓H␈↓manipulators␈α∂or␈α∂devices␈α⊂might␈α∂be␈α∂running␈α∂simultaneously,␈α⊂and␈α∂each␈α∂motor␈α∂requires␈α⊂a␈α∂separate
␈↓ ↓H␈↓process;␈α∀several␈α∀condition␈α∀monitors␈α∀might␈α∀be␈α∀active;␈α∀several␈α∀code␈α∀segments␈α∀(doing,␈α∀perhaps,
␈↓ ↓H␈↓calculations)␈α∞might␈α∂be␈α∞simultaneously␈α∞active.␈α∂ Those␈α∞processes␈α∞which␈α∂are␈α∞dealing␈α∂with␈α∞real-time
␈↓ ↓H␈↓devices␈α(joint␈αservos␈α
and␈αcondition␈αcheckers)␈α
must␈αbe␈αguaranteed␈α
service␈αat␈αregular␈α
intervals;␈αthe
␈↓ ↓H␈↓computation processes can fill in any time gaps.

␈↓"↓␈↓ ↓H␈↓␈↓ αλTrajectories␈α∩are␈α∩calculated␈α∩by␈α∩the␈α∩compiler␈α∩on␈α∩the␈α∩basis␈α∩of␈α∩incomplete␈α∩information.␈α∩ At
␈↓ ↓H␈↓runtime,␈αit␈αis␈αnecessary␈αto␈αmodify␈αthose␈αplans␈α
to␈αfit␈αthem␈αto␈αthe␈αsomewhat␈αdifferent␈αactual␈α
location
␈↓ ↓H␈↓of objects.  Certain information must be carried at runtime to accomplish this modification.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α
wide␈αrange␈α
of␈α
conceivable␈αtasks␈α
implies␈α
that␈αpure␈α
hardware␈α
servoing␈αdoes␈α
not␈αin␈α
general
␈↓ ↓H␈↓suffice.␈α
 The␈αreason␈α
for␈αthis␈α
is␈α
that␈αhardware␈α
servoing␈αrestricts␈α
use␈α
to␈αone␈α
of␈αa␈α
small␈α
number␈αof
␈↓ ↓H␈↓servo␈α⊗modes␈α⊗(typically␈α↔position,␈α⊗velocity,␈α⊗or␈α↔force),␈α⊗and␈α⊗has␈α↔no␈α⊗provision␈α⊗for␈α↔motions␈α⊗of
␈↓ ↓H␈↓accommodation␈α∩or␈α∩motions␈α∩whose␈α∩modes␈α∩might␈α∩change␈α∩in␈α∩midstream␈α∩due␈α∩to␈α∩some␈α∩software-
␈↓ ↓H␈↓detectable␈α
condition.␈α
 Pure␈α
hardware␈α
servoing␈α
could␈α∞not␈α
be␈α
readily␈α
modified␈α
to␈α
account␈α∞for␈α
new
␈↓ ↓H␈↓feedback␈α⊃devices␈α∩or␈α⊃methods.␈α∩ A␈α⊃philosophy␈α∩of␈α⊃␈↓βsoftware␈α∩servoing␈↓␈α⊃has␈α∩these␈α⊃advantages:␈α∩It␈α⊃is
␈↓ ↓H␈↓possible␈αto␈α
program␈αthe␈α
manner␈αin␈α
which␈αfeedback␈α
is␈αto␈α
be␈αused,␈α
to␈αinterface␈α
new␈αtypes␈αof␈α
sensors,
␈↓ ↓H␈↓to␈αmodify␈αthe␈αservo␈αwhile␈αthe␈αarm␈αis␈αin␈αmotion,␈αto␈αsupply␈αthe␈αdriving␈αprogram␈α
with␈αinformation
␈↓ ↓H␈↓concerning␈α
the␈α
success␈α
of␈α
the␈α
motion␈α
as␈α
well␈α∞as␈α
to␈α
keep␈α
it␈α
up-to-date␈α
on␈α
the␈α
arm␈α
status.␈α∞ It␈α
also
␈↓ ↓H␈↓allows␈α∪coordination␈α∩of␈α∪several␈α∪arms,␈α∩with␈α∪one␈α∪acting␈α∩as␈α∪a␈α∪master␈α∩and␈α∪the␈α∪others␈α∩following.
␈↓ ↓H␈↓Hardware␈α∞servoing␈α∂would␈α∞not␈α∂save␈α∞computation␈α∂since␈α∞the␈α∂computer␈α∞would␈α∂need␈α∞to␈α∂perform␈α∞an
␈↓ ↓H␈↓equivalent␈α
servo␈αcalculation␈α
in␈α
order␈αto␈α
understand␈α
what␈αthe␈α
manipulator␈α
is␈αdoing␈α
to␈αinteract␈α
with
␈↓ ↓H␈↓the task.



␈↓"↓␈↓ ↓H␈↓␈↓∧1.3 GENERAL SYSTEM OUTLINE␈↓



␈↓"↓␈↓ ↓H␈↓␈↓βHARDWARE␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλCurrently␈αtwo␈αStanford␈α
Electric␈αArms,␈αbuilt␈αby␈α
Victor␈αScheinman␈α[Scheinman],␈αare␈α
available.
␈↓ ↓H␈↓They␈αare␈αcalled␈αYELLOW␈αand␈αBLUE.␈α Each␈αhas␈αsix␈αjoints␈αand␈αa␈αhand␈αthat␈αcan␈αopen␈αand␈αclose.
␈↓ ↓H␈↓The␈α
joints␈α∞are␈α
controlled␈α
by␈α∞electric␈α
motors;␈α
each␈α∞joint␈α
has␈α
both␈α∞position␈α
and␈α∞velocity␈α
feedback.
␈↓ ↓H␈↓Motor␈α
drives␈α
are␈α
sent␈αfrom␈α
the␈α
computer␈α
to␈α
the␈αarm␈α
via␈α
a␈α
digital-to-analog␈α
converter␈α(D-to-A);
␈↓ ↓H␈↓feedback␈α⊗signals␈α⊗are␈α⊗routed␈α⊗through␈α⊗an␈α⊗analog-to-digital␈α⊗converter␈α⊗(A-to-D)␈α⊗back␈α↔to␈α⊗the
␈↓ ↓H␈↓computer.

␈↓"↓␈↓ ↓H␈↓␈↓ αλVarious␈α⊂other␈α⊂devices␈α⊃are␈α⊂designed␈α⊂and␈α⊃implemented␈α⊂as␈α⊂needed.␈α⊃ We␈α⊂use␈α⊂tools,␈α⊃jigs␈α⊂and
␈↓ ↓H␈↓special␈αmarkings␈αfor␈α
several␈αpurposes:␈αto␈αrender␈α
a␈αtask␈αpossible␈α(an␈α
example␈αis␈αthe␈αarm␈α
itself),␈αto
␈↓ ↓H␈↓improve␈α∃efficiency␈α∃(a␈α∃mechanical␈α∃screwdriver),␈α∃and␈α∃to␈α∃overcome␈α∃some␈α∃of␈α∃our␈α∃sensory␈α∃and
␈↓ ↓H␈↓mechanical limitations (a screw dispenser).
␈↓ ↓H␈↓Page 4␈↓ ∧hGENERAL SYSTEM OUTLINE␈↓ ∂1.3.1



␈↓"∧␈↓ ↓H␈↓␈↓ αλAL␈α⊃resides␈α⊃on␈α⊃two␈α⊂computers:␈α⊃The␈α⊃PDP-10␈α⊃for␈α⊃all␈α⊂planning,␈α⊃and␈α⊃a␈α⊃PDP-11/45␈α⊃for␈α⊂the
␈↓ ↓H␈↓execution␈α∞of␈α∞the␈α∞plans.␈α∞ The␈α∞former␈α∞is␈α∞run␈α∞as␈α∞a␈α∞timesharing␈α∞computer␈α∞(under␈α∞a␈α∞modified␈α
DEC
␈↓ ↓H␈↓system);␈αthe␈αlatter␈αis␈αoperated␈αin␈αstand-alone␈αmode␈αunder␈αthe␈αAL␈αruntime␈αsystem.␈α Each␈αcomputer
␈↓ ↓H␈↓is␈αcapable␈αof␈αgenerating␈αan␈αinterrupt␈αin␈αthe␈αother,␈αand␈αthe␈αPDP-10␈αhas␈αcomplete␈αcontrol␈αover␈αthe
␈↓ ↓H␈↓PDP-11␈α⊃console␈α∩and␈α⊃unibus.␈α⊃ It␈α∩is␈α⊃not␈α∩certain␈α⊃exactly␈α⊃what␈α∩the␈α⊃minimum␈α∩runtime␈α⊃computer
␈↓ ↓H␈↓configuration␈αwill␈αbe;␈αwe␈αuse␈αfloating␈αpoint␈αand␈αmemory␈αmanagement,␈αbut␈αit␈αis␈αnot␈αclear␈αthat␈αthis
␈↓ ↓H␈↓is altogether necessary.



␈↓"↓␈↓ ↓H␈↓␈↓βSOFTWARE␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλSee Figure 1 for a picture of the system.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α∩SUPERVISOR␈α⊃is␈α∩the␈α⊃top␈α∩level␈α⊃of␈α∩AL.␈α⊃ It␈α∩runs␈α⊃on␈α∩the␈α⊃timesharing␈α∩computer␈α⊃and
␈↓ ↓H␈↓provides␈αan␈αinterface␈αbetween␈αthe␈αuser␈αand␈αthe␈αother␈αparts␈αof␈αthe␈αsystem:␈α1)␈αlistening␈αto␈αthe␈αuser's
␈↓ ↓H␈↓console␈α
and␈α∞interpreting␈α
simple␈α
command␈α∞language␈α
input;␈α
2)␈α∞controlling␈α
the␈α
compiler,␈α∞starting␈α
it
␈↓ ↓H␈↓and␈α
relaying␈α
its␈α
error␈α
messages␈α
back␈α
to␈α
the␈α
user;␈α
3)␈α
signalling␈α
the␈α
loader␈α
when␈α
it␈α
is␈α∞necessary␈α
to
␈↓ ↓H␈↓place compiled code into the mini; 4) handling the runtime interface to the mini.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α∞USER␈α∞sits␈α
at␈α∞a␈α∞console␈α
and␈α∞makes␈α∞requests␈α
of␈α∞AL.␈α∞ These␈α
fall␈α∞into␈α∞several␈α
categories:
␈↓ ↓H␈↓compilation,␈αloading,␈αexecution␈αof␈αprograms,␈αdebugging␈αof␈αcode,␈αrequesting␈αof␈α
status␈αinformation,
␈↓ ↓H␈↓asking␈α⊂for␈α⊂immediate␈α⊂arm␈α⊂motion,␈α⊂saving␈α⊂and␈α⊂restoring␈α⊂the␈α⊂state␈α⊂of␈α⊂the␈α⊂world␈α⊂at␈α⊂safe␈α⊂points,
␈↓ ↓H␈↓requesting␈αexplanation␈αof␈αcertain␈αcompiler␈αdecisions.␈αThere␈αare␈αtwo␈αdifferent␈αconsoles␈αat␈α
which␈αa
␈↓ ↓H␈↓user␈α
can␈α
sit:␈α∞one␈α
is␈α
connected␈α∞to␈α
the␈α
timesharing␈α∞computer,␈α
through␈α
which␈α∞she␈α
can␈α
speak␈α∞to␈α
the
␈↓ ↓H␈↓supervisor␈α
and␈αall␈α
the␈α
parts␈αof␈α
AL␈αresiding␈α
on␈α
the␈αtimesharing␈α
computer;␈α
the␈αother␈α
is␈αconnected␈α
to
␈↓ ↓H␈↓the mini, and through it the user can investigate the runtime system and cause modifications.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α⊃COMPILER␈α⊃reads␈α⊃AL␈α⊃programs␈α∩from␈α⊃files␈α⊃(or,␈α⊃optionally,␈α⊃directly␈α⊃from␈α∩the␈α⊃user's
␈↓ ↓H␈↓console)␈α
and␈α
produces␈α
load␈α
modules.␈α
 The␈α
compiler␈α
is␈α
divided␈α
into␈α
three␈α
phases:␈α
The␈α
PARSER,
␈↓ ↓H␈↓which␈αproduces␈αparse␈α
trees␈αof␈αthe␈αprogram,␈α
the␈αEXPANDER,␈αwhich␈α
expands␈αthose␈αparse␈αtrees␈α
by
␈↓ ↓H␈↓replacing␈α#high-level␈α$primitives␈α#with␈α#low-level␈α$primitives,␈α#and␈α$the␈α#TRAJECTORY
␈↓ ↓H␈↓CALCULATOR and CODE GENERATOR, which creates the output files.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α∞LOADER␈α
takes␈α∞the␈α
load␈α∞modules␈α∞prepared␈α
by␈α∞the␈α
compiler␈α∞and␈α
enters␈α∞them␈α∞into␈α
the
␈↓ ↓H␈↓mini's␈αruntime␈αsystem.␈α Address␈αrelocation␈αand␈αlinking␈αare␈αdone␈αat␈αthis␈αtime.␈αThe␈αloader␈αalso␈αsets
␈↓ ↓H␈↓up␈αthe␈αdata␈αarea␈αin␈αthe␈αruntime␈αinterface␈αin␈αthe␈αtimesharing␈αcomputer;␈αthese␈αdata␈αinclude␈αoutput
␈↓ ↓H␈↓strings,␈α⊂procedure␈α⊂linkages,␈α⊂and␈α⊂information␈α∂necessary␈α⊂for␈α⊂diagnostic␈α⊂purposes␈α⊂during␈α∂runtime.
␈↓ ↓H␈↓Loading␈αis␈αoften␈αdone␈αin␈αa␈αpartially␈αincremental␈αfashion,␈αinstalling␈αnew␈αcode␈αfollowing␈αpreviously
␈↓ ↓H␈↓loaded code.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈αRUNTIME␈αINTERFACE,␈α
which␈αresides␈αin␈αthe␈α
timesharing␈αcomputer,␈αis␈α
charged␈αwith
␈↓ ↓H␈↓initiating␈αthe␈αmini␈αprogram,␈αfielding␈αprocedure␈αcalls␈αfrom␈αthe␈αrunning␈αprogram␈αto␈αprocedures␈αon
␈↓ ↓H␈↓the␈α∞timesharing␈α∞machine,␈α∞returning␈α
values␈α∞from␈α∞these␈α∞procedures,␈α
and␈α∞fetching␈α∞values␈α∞from␈α
the
␈↓ ↓H␈↓mini␈α⊂for␈α⊂debugging␈α⊂purposes.␈α⊂ The␈α⊂interface␈α⊂has␈α⊂the␈α⊂power␈α⊂to␈α⊂interrupt␈α⊂the␈α⊂execution␈α⊃of␈α⊂the
␈↓ ↓H␈↓program␈α
and␈αto␈α
modify␈α
the␈αstatus␈α
of␈αthe␈α
runtime␈α
system,␈αfor␈α
example,␈αby␈α
patching␈α
in␈αadditional
␈↓ ↓H␈↓programs␈αor␈αmodifying␈αthe␈αvalues␈αof␈αsome␈αvariables.␈α This␈αallows␈αthe␈αuser␈αto␈αcontrol␈αthe␈α
program
␈↓ ↓H␈↓through the timesharing computer.

␈↓"↓␈↓ ↓H␈↓␈↓ αλThe␈α∂RUNTIME␈α∞SYSTEM␈α∂is␈α∞the␈α∂set␈α∂of␈α∞programs␈α∂which␈α∞reside␈α∂in␈α∞the␈α∂mini.␈α∂ This␈α∞system
␈↓ ↓H␈↓includes␈αkernel␈αprograms␈αfor␈αtime-slice␈αcpu␈αsharing␈αand␈αprocess␈αcontrol␈αand␈αa␈αset␈α
of␈αdynamically
␈↓ ↓H␈↓created␈α⊂processes.␈α⊂ These␈α⊂are␈α⊂of␈α⊂three␈α⊂basic␈α⊂types:␈α⊂a)␈α⊂An␈α⊂INTERPRETER␈α⊂examines␈α⊃the␈α⊂code
␈↓ ↓H␈↓prepared␈αby␈αthe␈αcompiler␈αand␈αexecutes␈α
the␈αnumeric␈αcomputations␈αrequested.␈α When␈αa␈αmove␈α
is␈αto
␈↓ ↓H␈↓be␈α⊃started,␈α⊃the␈α⊃interpreter␈α⊃creates␈α⊂a␈α⊃servo␈α⊃for␈α⊃each␈α⊃joint␈α⊂and␈α⊃waits␈α⊃until␈α⊃all␈α⊃these␈α⊃servos␈α⊂are
␈↓ ↓H␈↓finished.␈α
 b)␈α
A␈α
SERVO␈α
handles␈α
the␈α
motion␈α
of␈α
one␈α
moving␈α
joint.␈α
c)␈α
A␈α
CONDITION-MONITOR
␈↓ ↓H␈↓repeatedly␈α⊂examines␈α⊂certain␈α⊃conditions␈α⊂(whatever␈α⊂the␈α⊂programmer␈α⊃has␈α⊂specified).␈α⊂ If␈α⊃it␈α⊂should
␈↓ ↓H␈↓discover␈αthat␈αits␈αcondition␈αhas␈αoccurred,␈αit␈αcreates␈αan␈αinterpreter␈αto␈αtake␈αappropriate␈αaction.␈α The
␈↓ ↓H␈↓runtime␈α∪system␈α∀also␈α∪includes␈α∀routines␈α∪for␈α∪communication␈α∀with␈α∪the␈α∀runtime␈α∪interface␈α∀in␈α∪the
␈↓ ↓H␈↓timesharing computer.
␈↓ ↓H␈↓1.3.2␈↓ ∧hGENERAL SYSTEM OUTLINE␈↓ 
pPage 5




































␈↓ ↓H␈↓␈↓ εαFigure    1
␈↓ ↓H␈↓␈↓ ¬hOverall system





␈↓"↓␈↓ ↓H␈↓␈↓∧2 AN EXAMPLE␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλA␈αsimple␈αtask␈α
dealing␈αwith␈αthe␈α
objects␈αshown␈αin␈α
Figure␈α2␈αillustrates␈α
some␈αof␈αthe␈α
features␈αof
␈↓ ↓H␈↓AL:
␈↓ ↓H␈↓␈↓ αh1.␈α Pick␈αup␈αthe␈αbracket␈αwith␈αthe␈αYELLOW␈αarm␈αand␈αposition␈αit␈αnext␈αto␈αthe␈α
beam␈αso
␈↓ ↓H␈↓␈↓ αhthat the holes line up,
␈↓ ↓H␈↓␈↓ αh2.  Pick up the bolt with the BLUE arm,
␈↓ ↓H␈↓␈↓ αh3.  Fasten the bracket to the beam by inserting the bolt in the holes,
␈↓ ↓H␈↓␈↓ αh4.  Return the arms to their park positions.

␈↓"↓␈↓ ↓H␈↓␈↓ αλSome␈α
of␈α
the␈α
features␈α
to␈α
be␈α
demonstrated␈α
are:␈α
the␈α
affix␈α
structure,␈α
reference␈α
frames,␈α
dimensions,
␈↓ ↓H␈↓and␈α
multi-processing.␈α∞ We␈α
demonstrate␈α∞these␈α
capabilities␈α∞by␈α
presenting␈α∞a␈α
highly␈α∞commented␈α
AL
␈↓ ↓H␈↓program to accomplish the task stated above.
␈↓ ↓H␈↓Page 6␈↓ εH␈↓ H




































␈↓ ↓H␈↓␈↓ εαFigure    2
␈↓ ↓H␈↓␈↓ ¬ELayout for Example



␈↓"↓␈↓ ↓H␈↓␈↓ αλAL␈α⊃is␈α⊃a␈α∩multi-level␈α⊃programming␈α⊃language;␈α∩at␈α⊃one␈α⊃extreme␈α∩the␈α⊃user␈α⊃can␈α∩write␈α⊃detailed,
␈↓ ↓H␈↓system-like␈αprograms␈αand␈αat␈αthe␈αother␈αshe␈αcan␈αdescribe␈αthe␈αtasks␈αand␈αany␈αpartial␈αordering␈αamong
␈↓ ↓H␈↓them␈α
and␈α
let␈α
the␈α
system␈α
determine␈α
necessary␈α
details.␈α
 Our␈α
example␈α
is␈α
written␈α
in␈α
an␈α
intermediate
␈↓ ↓H␈↓level.␈α In␈αparticular,␈αit␈αassumes␈αthat␈αthere␈αare␈αseveral␈αgeneral-purpose␈αmacros␈αand␈αroutines␈αwhich
␈↓ ↓H␈↓understand␈α
how␈α
to␈α
GRASP␈αand␈α
RELEASE␈α
things␈α
and␈αcarry␈α
out␈α
a␈α
NORMAL_SEARCH␈αto␈α
insert
␈↓ ↓H␈↓something into a hole.

␈↓"↓␈↓ ↓H␈↓␈↓ αλCapitalized␈α∂words␈α∞in␈α∂the␈α∂example␈α∞are␈α∂key␈α∂words␈α∞within␈α∂AL.␈α∂ Lower␈α∞case␈α∂words␈α∂are␈α∞user-
␈↓ ↓H␈↓defined identifiers.  Comments are surrounded by curly brackets.
␈↓ ↓H␈↓whole_task: BEGIN

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{First␈α∀declare␈α∀the␈α∃necessary␈α∀FRAMEs␈α∀and␈α∀describe␈α∃how␈α∀they␈α∀are␈α∀initially␈α∃related.␈α∀ The
␈↓ ↓H␈↓β␈↓ αλattach␈α~structure␈α→representing␈α~the␈α→initial␈α~world␈α→is␈α~shown␈α→in␈α~Figure␈α→3.␈α~ The␈α→arrows
␈↓ ↓H␈↓β␈↓ αλindicate␈α⊂how␈α⊂the␈α⊂movement␈α⊃of␈α⊂a␈α⊂frame␈α⊂affects␈α⊃other␈α⊂frames.␈α⊂ If␈α⊂a␈α⊃frame␈α⊂at␈α⊂the␈α⊂tail␈α⊃of␈α⊂an
␈↓ ↓H␈↓β␈↓ αλarrow␈α∪is␈α∪moved␈α∪(by␈α∩the␈α∪arm,␈α∪visually␈α∪updated,␈α∩etc.)␈α∪the␈α∪frame␈α∪at␈α∩the␈α∪head␈α∪of␈α∪the␈α∩arrow
␈↓ ↓H␈↓β␈↓ αλwill␈α⊃be␈α⊃automatically␈α⊃updated.␈α⊃ The␈α⊃double␈α⊂arrows␈α⊃are␈α⊃the␈α⊃results␈α⊃of␈α⊃RIGIDLY␈α⊂AFFIXing
␈↓ ↓H␈↓β␈↓ αλone frame to another.}
␈↓ ↓H␈↓␈↓ εH␈↓ 
pPage 7


















































␈↓ ↓H␈↓␈↓ εαFigure    3
␈↓ ↓H␈↓␈↓ ∧IAttach Structure for the Task Example


␈↓ ↓H␈↓FRAME beam, beam_hole;          FRAME bolt;
␈↓ ↓H␈↓FRAME bracket, bracket_hole, bracket_grasp;
␈↓ ↓H␈↓beam ← FRAME(ROT(Z, 90*DEG), VECTOR(10,6,0));
␈↓ ↓H␈↓Page 8␈↓ εH␈↓ H



␈↓"∧␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α∩beam␈α∩is␈α∪expected␈α∩to␈α∩be␈α∪positioned␈α∩at␈α∩(10,6,0)␈α∩in␈α∪the␈α∩station's␈α∩coordinate␈α∪system␈α∩(all
␈↓ ↓H␈↓β␈↓ αλmeasurements␈α⊂are␈α⊂in␈α⊂centimeters)␈α⊂and␈α⊂rotated␈α⊂90␈α⊂degrees␈α⊂about␈α⊂the␈α⊂station's␈α⊂Z␈α⊃vector.␈α⊂ AL
␈↓ ↓H␈↓β␈↓ αλknows␈α_about␈α_dimensions␈α_like␈α_DEG␈α_for␈α_degrees.␈α_ Dimensions␈α_are␈α_adjuncts␈α→to␈α_variable
␈↓ ↓H␈↓β␈↓ αλtypes; new ones can be defined in terms of old ones.}
␈↓ ↓H␈↓beam_hole ← beam*TRANS(ROT(X, 90*DEG), VECTOR(3,0,7));

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α∃TRANS␈α∃represents␈α∃the␈α∀position␈α∃of␈α∃the␈α∃beam_hole␈α∀with␈α∃respect␈α∃to␈α∃the␈α∃beam.␈α∀ The
␈↓ ↓H␈↓β␈↓ αλpremultiplication␈α∃by␈α∃the␈α⊗frame␈α∃beam␈α∃positions␈α∃the␈α⊗beam_hole␈α∃in␈α∃the␈α⊗station's␈α∃coordinate
␈↓ ↓H␈↓β␈↓ αλsystem.}
␈↓ ↓H␈↓AFFIX beam_hole TO beam; ␈↓β{As shown in Figure 3}␈↓
␈↓ ↓H␈↓ASSERT FORM(DEPROACH, beam_hole, TRANS(NILROT,VECTOR(0,0,-3));

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{Trajectories␈α↔consist␈α_of␈α↔a␈α↔path␈α_from␈α↔the␈α↔current␈α_position,␈α↔through␈α↔a␈α_departure␈α↔point,
␈↓ ↓H␈↓β␈↓ αλpossibly␈α≤through␈α≤some␈α≤via␈α≤points,␈α≤through␈α≠an␈α≤approach␈α≤point,␈α≤and␈α≤finally␈α≤to␈α≠the
␈↓ ↓H␈↓β␈↓ αλdestination.␈α⊂ All␈α⊂FRAMEs␈α⊂have␈α⊂a␈α⊂DEPROACH␈α⊂TRANS␈α⊂associated␈α⊂with␈α⊂them.␈α⊂ TRANSes
␈↓ ↓H␈↓β␈↓ αλare␈α∩essentially␈α∪the␈α∩same␈α∪as␈α∩FRAMEs.␈α∪ Whenever␈α∩leaving␈α∪(or␈α∩moving␈α∪to)␈α∩a␈α∪FRAME␈α∩the
␈↓ ↓H␈↓β␈↓ αλstandard␈α∃departure␈α⊗(or␈α∃approach)␈α⊗used␈α∃is␈α∃that␈α⊗FRAME's␈α∃DEPROACH␈α⊗TRANS.␈α∃ The
␈↓ ↓H␈↓β␈↓ αλstation␈α→has␈α→a␈α→DEPROACH␈α→TRANS␈α~which␈α→is␈α→three␈α→inches␈α→above␈α→it.␈α~ Whenever␈α→one
␈↓ ↓H␈↓β␈↓ αλFRAME␈α⊃is␈α⊃AFFIXed␈α∩to␈α⊃another,␈α⊃by␈α∩default␈α⊃the␈α⊃former␈α∩takes␈α⊃on␈α⊃the␈α∩later's␈α⊃DEPROACH.
␈↓ ↓H␈↓β␈↓ αλThe␈α∩result␈α∩of␈α∩this␈α∩ASSERT␈α∩is␈α∩that␈α∩the␈α∩arms␈α∩will␈α∩approach␈α∩the␈α∩beam␈α∩hole␈α∩from␈α∩the␈α⊃side
␈↓ ↓H␈↓β␈↓ αλinstead of from above.
␈↓ ↓H␈↓bracket ← FRAME(ROT(Z,45*DEG),VECTOR(20,14,0));
␈↓ ↓H␈↓bracket_hole ← bracket*TRANS(ROT(X,180*DEG),VECTOR(3,3,0));
␈↓ ↓H␈↓AFFIX bracket_hole TO bracket;
␈↓ ↓H␈↓bracket_grasp ← bracket*TRANS(ROT(X,180*DEG),VECTOR(0,3,3));
␈↓ ↓H␈↓AFFIX bracket_grasp TO bracket RIGIDLY;

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α~RIGID␈α~AFFIXment␈α~insures␈α~that␈α→a␈α~change␈α~of␈α~bracket_grasp␈α~will␈α→automatically
␈↓ ↓H␈↓β␈↓ αλchange␈α→bracket,␈α_which␈α→in␈α→turn␈α_will␈α→automatically␈α→change␈α_bracket_hole.␈α→ This␈α→is␈α_quite
␈↓ ↓H␈↓β␈↓ αλconvenient␈α∩if␈α∩the␈α∩position␈α⊃of␈α∩the␈α∩whole␈α∩`object'␈α∩is␈α⊃being␈α∩updated␈α∩by␈α∩one␈α∩grasping␈α⊃position
␈↓ ↓H␈↓β␈↓ αλ(ie. bracket_grasp).}
␈↓ ↓H␈↓bolt ← FRAME(ROT(Z,90*DEG)*ROT(X,180*DEG),VECTOR(16,30,0));

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α⊂rotation␈α⊂portion␈α⊂of␈α⊂the␈α⊂FRAME␈α⊂has␈α⊂been␈α⊂specified␈α⊂as␈α⊂a␈α⊂composition␈α⊂of␈α⊂two␈α⊂primitive
␈↓ ↓H␈↓β␈↓ αλrotations.}
␈↓ ↓H␈↓DEFINE OZ = "72.007789*DYNES";

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{Some of the standard macros are defined next.}
␈↓ ↓H␈↓DEFINE grasp(TRANS special_departure,special_approach;
␈↓ ↓H␈↓    FRAME ATOM the_arm (DEFAULT YELLOW);
␈↓ ↓H␈↓    FRAME object,grasp_point,thing_object_affixed_to;
␈↓ ↓H␈↓    DISTANCE SCALAR opening_before_departure,
␈↓ ↓H␈↓        opening_for_approach(DEFAULT 15*CM),
␈↓ ↓H␈↓        thickness(DEFAULT .3*CM)) = " ... ";

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α≥expansion␈α≤of␈α≥such␈α≤a␈α≥macro␈α≤can␈α≥depend␈α≤upon␈α≥the␈α≤supplied␈α≥arguments,␈α≤the
␈↓ ↓H␈↓β␈↓ αλDEFAULT arguments, and any values in the current planning model.}
␈↓ ↓H␈↓DEFINE release(FRAME ATOM the_arm(DEFAULT YELLOW);
␈↓ ↓H␈↓    FRAME the_object,the_new_parent;
␈↓ ↓H␈↓    DISTANCE SCALAR the_opening(DEFAULT 15*CM)) = " ... ";
␈↓ ↓H␈↓DEFINE normal_search(FRAME ATOM the_arm(DEFAULT YELLOW);
␈↓ ↓H␈↓    DISTANCE SCALAR increment(DEFAULT .3*CM), distance_fwd;
␈↓ ↓H␈↓    FORCE SCALAR stopping_force;
␈↓ ↓H␈↓    SCALAR number_of_tries(DEFAULT 9)) = " ... ";

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{This␈α↔includes␈α⊗some␈α↔automatic␈α⊗error␈α↔recovery␈α⊗and␈α↔a␈α⊗call␈α↔to␈α⊗the␈α↔operator␈α↔if␈α⊗something
␈↓ ↓H␈↓β␈↓ αλdrastic goes wrong.}
␈↓ ↓H␈↓COBEGIN
␈↓ ↓H␈↓␈↓ εH␈↓ 
pPage 9



␈↓"∧␈↓ ↓H␈↓␈↓ αλ␈↓β{This␈α≡COBEGIN-COEND␈α∨construction␈α≡describes␈α≡two␈α∨independent␈α≡subtasks␈α∨(one␈α≡for
␈↓ ↓H␈↓β␈↓ αλYELLOW␈α∃and␈α∃one␈α⊗for␈α∃BLUE)␈α∃which␈α⊗can␈α∃be␈α∃executed␈α∃in␈α⊗any␈α∃order␈α∃determined␈α⊗by␈α∃the
␈↓ ↓H␈↓β␈↓ αλruntime␈α∩system;␈α⊃in␈α∩parallel␈α⊃or␈α∩serially.␈α⊃ This,␈α∩of␈α⊃course,␈α∩assumes␈α⊃that␈α∩the␈α⊃two␈α∩arms␈α⊃work
␈↓ ↓H␈↓β␈↓ αλin completely separate parts of the workstation so there is no possibility of a collision.}
␈↓ ↓H␈↓    ypickup: BEGIN ␈↓β{pick up the bracket with yellow}␈↓
␈↓ ↓H␈↓    grasp(object=bracket,grasp_point=bracket_grasp,opening_for_approach=3*CM);

␈↓"↓␈↓ ↓H␈↓␈↓ αH␈↓β{Only␈α∩the␈α∩necessary␈α∩parameters␈α∩need␈α∩to␈α∩be␈α∩specified.␈α∩ By␈α∩default␈α∩the␈α∪YELLOW␈α∩arm
␈↓ ↓H␈↓β␈↓ αHwill␈α∪be␈α∪used␈α∪and␈α∪there␈α∪will␈α∪be␈α∩no␈α∪special␈α∪approaches␈α∪or␈α∪departures.␈α∪ One␈α∪effect␈α∩of
␈↓ ↓H␈↓β␈↓ αHgrasp is to AFFIX the object to the arm.}
␈↓ ↓H␈↓    MOVE bracket_hole TO beam_hole + VECTOR(0,0,-.3) WRT beam_hole;

␈↓"↓␈↓ ↓H␈↓␈↓ αH␈↓β{The␈α∀YELLOW␈α∃arm␈α∀(since␈α∀it␈α∃holds␈α∀the␈α∀bracket␈α∃to␈α∀which␈α∀bracket_hole␈α∃is␈α∀AFFIXed)
␈↓ ↓H␈↓β␈↓ αHpositions␈α∀itself␈α∀so␈α∀that␈α∀the␈α∀bracket_hole␈α∀lines␈α∀up␈α∀with␈α∀the␈α∀beam_hole,␈α∀but␈α∀is␈α∀.3␈α∪cm
␈↓ ↓H␈↓β␈↓ αHaway␈α∃from␈α⊗the␈α∃beam_hole.␈α∃ The␈α⊗WRT␈α∃operator␈α⊗is␈α∃one␈α∃way␈α⊗of␈α∃describing␈α⊗a␈α∃vector
␈↓ ↓H␈↓β␈↓ αHwithin a frame of reference other than the station's.}
␈↓ ↓H␈↓    MOVE YELLOW TO ⊗ + VECTOR(0,0,.6) WRT beam_hole
␈↓ ↓H␈↓        ON FORCE(Z WRT beam_hole)>50*OZ DO STOP YELLOW
␈↓ ↓H␈↓        ON ARRIVAL DO ABORT("***  error   ***  bracket  went  too  far");

␈↓"↓␈↓ ↓H␈↓␈↓ αH␈↓β{The␈α∃⊗␈α∃represents␈α⊗the␈α∃current␈α∃position␈α∃of␈α⊗the␈α∃arm.␈α∃ The␈α∃arm␈α⊗moves␈α∃.6␈α∃cm␈α⊗in␈α∃Z
␈↓ ↓H␈↓β␈↓ αHrelative␈α∩to␈α∩the␈α∩beam_hole's␈α∩frame.␈α∩ The␈α∩purpose␈α∩of␈α∩this␈α∩move␈α∩is␈α∩to␈α∩push␈α∩the␈α∩bracket
␈↓ ↓H␈↓β␈↓ αHup␈α∪against␈α∪the␈α∪beam.␈α∪ If␈α∪the␈α∪beam␈α∪is␈α∪there,␈α∪the␈α∪arm␈α∪will␈α∪sense␈α∪an␈α∪opposing␈α∪force.
␈↓ ↓H␈↓β␈↓ αHIf␈α∪not,␈α∀the␈α∪arm␈α∪will␈α∀succeed␈α∪in␈α∪moving␈α∀forward␈α∪the␈α∪prescribed␈α∀.6␈α∪cm.␈α∪ In␈α∀order␈α∪to
␈↓ ↓H␈↓β␈↓ αHcheck␈α→for␈α_these␈α→possibilities,␈α→two␈α_condition␈α→monitors␈α→have␈α_been␈α→included␈α→with␈α_the
␈↓ ↓H␈↓β␈↓ αHMOVE␈α∪statement.␈α∩ The␈α∪first␈α∩one␈α∪monitors␈α∪the␈α∩force␈α∪and␈α∩stops␈α∪the␈α∩arm␈α∪if␈α∪the␈α∩force
␈↓ ↓H␈↓β␈↓ αHexceeds␈α∩50␈α∩ounces␈α∪(which␈α∩means␈α∩everything␈α∪is␈α∩ok).␈α∩ The␈α∪second␈α∩one␈α∩is␈α∪an␈α∩interrupt
␈↓ ↓H␈↓β␈↓ αHtype␈α⊃condition.␈α⊃ If␈α∩the␈α⊃arm␈α⊃successfully␈α⊃carries␈α∩out␈α⊃the␈α⊃complete␈α⊃MOVE,␈α∩this␈α⊃monitor
␈↓ ↓H␈↓β␈↓ αHis awakened, the message is printed, and control is given to an operator.}
␈↓ ↓H␈↓    END ypickup;
␈↓ ↓H␈↓    bpickup: BEGIN  ␈↓β{pick up the bolt with blue}␈↓
␈↓ ↓H␈↓    grasp(the_arm=BLUE,the_object=bolt,grasp_point=bolt,
␈↓ ↓H␈↓        opening_for_approach=3*CM);
␈↓ ↓H␈↓    END bpickup;
␈↓ ↓H␈↓COEND;

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{Figure 3 shows the world after the parts have been picked up.}
␈↓ ↓H␈↓MOVE bolt TO beam_hole + VECTOR(0,0,-5.3) WRT beam_hole;

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{The␈α∩BLUE␈α∩arm␈α∩positions␈α⊃itself␈α∩so␈α∩that␈α∩the␈α⊃bolt␈α∩is␈α∩lined␈α∩up␈α⊃with␈α∩the␈α∩beam_hole␈α∩and␈α⊃its
␈↓ ↓H␈↓β␈↓ αλtip is .3 cm away from the outside of the bracket_hole.}
␈↓ ↓H␈↓normal_search(BLUE, .2*CM, 1.6*CM, 60*OZ, 9);

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{This␈α∃pushes␈α∃the␈α∃bolt␈α∃thru␈α∃the␈α∃bracket_hole␈α∃and␈α∃partly␈α∃into␈α∃the␈α∃beam_hole.␈α⊗ If␈α∃control
␈↓ ↓H␈↓β␈↓ αλcontinues past this statement the bolt is assumed to be partly in the hole.}
␈↓ ↓H␈↓MOVE BLUE TO ⊗ * FRAME(ROT(Z,90*DEG),VECTOR(0,0,4))
␈↓ ↓H␈↓    ON FORCE(Z WRT BLUE) > 60*OZ DO STOP BLUE;

␈↓"↓␈↓ ↓H␈↓␈↓ αλ␈↓β{This␈α∪pushes␈α∀and␈α∪twists␈α∪the␈α∀bolt␈α∪into␈α∪the␈α∀hole.␈α∪ When␈α∪the␈α∀force␈α∪exceeds␈α∪60␈α∀ounces,␈α∪the
␈↓ ↓H␈↓β␈↓ αλbolt␈α∩is␈α⊃assumed␈α∩to␈α⊃be␈α∩completely␈α∩seated␈α⊃in␈α∩the␈α⊃hole.␈α∩ There␈α∩is␈α⊃no␈α∩check␈α⊃to␈α∩make␈α∩sure␈α⊃the
␈↓ ↓H␈↓β␈↓ αλbolt seats properly.}
␈↓ ↓H␈↓COBEGIN
␈↓ ↓H␈↓    parky: BEGIN  ␈↓β{release the bracket and park}␈↓
␈↓ ↓H␈↓    release(the_object=bracket,the_opening=3*CM,the_new_parent=beam);
␈↓ ↓H␈↓    MOVE YELLOW TO YPARK;
␈↓ ↓H␈↓    END parky;
␈↓ ↓H␈↓    parkb: BEGIN  ␈↓β{release the bolt and park}␈↓
␈↓ ↓H␈↓    release(the_arm=BLUE,the_object=bolt,the_opening=3*CM,the_new_parent=beam);
␈↓ ↓H␈↓Page 10␈↓ εH␈↓ H



␈↓"∧␈↓ ↓H␈↓    MOVE BLUE TO BPARK;
␈↓ ↓H␈↓    END parkb;
␈↓ ↓H␈↓COEND;
␈↓ ↓H␈↓END whole_task



␈↓"↓␈↓ ↓H␈↓␈↓∧3 CONCLUSIONS␈↓

␈↓"↓␈↓ ↓H␈↓␈↓ αλAL␈α
is␈α
important␈α
for␈α
several␈α
reasons.␈α
 It␈αshows␈α
what␈α
sort␈α
of␈α
considerations␈α
are␈α
necessary␈αfor
␈↓ ↓H␈↓flexible␈α∩control␈α⊃of␈α∩mechanical␈α⊃manipulation.␈α∩ It␈α⊃demonstrates␈α∩the␈α⊃feasibility␈α∩of␈α⊃programmable
␈↓ ↓H␈↓assembly.␈α∪ It␈α∪provides␈α∪a␈α∩research␈α∪tool␈α∪for␈α∪investigation␈α∩of␈α∪new␈α∪modes␈α∪of␈α∪software␈α∩servoing,
␈↓ ↓H␈↓assembly primitives, arm-control primitives, and interactive real-time real-world systems.

␈↓"↓␈↓ ↓H␈↓␈↓ αλAL␈αis␈αcurrently␈αlimited␈αby␈αthe␈αlack␈αof␈αcertain␈αfeatures␈αwhich␈αwould␈αmake␈αit␈αmore␈αcompetent.
␈↓ ↓H␈↓Many␈α
of␈α
these␈α
have␈α
to␈α
do␈α
with␈α
the␈α
fact␈α
that␈α
feedback␈α
is␈α
used␈α
only␈α
in␈α
a␈α
threshold␈α
way;␈α∞either␈α
a
␈↓ ↓H␈↓monitor␈α∞triggers␈α∞or␈α∂it␈α∞does␈α∞not.␈α∂ Fine␈α∞control␈α∞of␈α∂the␈α∞arm␈α∞would␈α∂be␈α∞enhanced␈α∞by␈α∂more␈α∞sensitive
␈↓ ↓H␈↓force-sensing␈αelements␈αon␈αthe␈αhand␈αand␈αa␈αmeans␈αof␈αprogramming␈αaccommodating,␈αnon-threshold
␈↓ ↓H␈↓response␈α∃to␈α∀this␈α∃sensory␈α∀input.␈α∃ Visual␈α∀feedback␈α∃should␈α∀be␈α∃implemented␈α∀to␈α∃provide␈α∀better
␈↓ ↓H␈↓positioning␈αcapability,␈αerror␈α
detection,␈αand␈αerror␈αrecovery.␈α
 Moving␈αassembly␈αlines␈αimply␈α
that␈αAL
␈↓ ↓H␈↓should␈αbe␈α
able␈αto␈α
handle␈αmotions␈α
which␈αit␈αdoes␈α
not␈αcause␈α
directly␈αthrough␈α
manipulation;␈αobjects
␈↓ ↓H␈↓should␈αhave␈αa␈αdynamic␈α
capablility.␈α Collision␈αdetection␈αand␈α
avoidance␈αremain␈αdifficult␈αissues.␈α
 AL
␈↓ ↓H␈↓would␈α∞be␈α
more␈α∞error-free␈α
if␈α∞the␈α∞trajectory␈α
calculator␈α∞could␈α
ensure␈α∞that␈α
the␈α∞arms␈α∞never␈α
interfere
␈↓ ↓H␈↓with each other or with objects in the current world.